import Vue from 'vue'
import { getToken } from '@/utils/auth'
import { Notification } from 'element-ui'

// 创建一个事件总线
export const WebSocketBus = new Vue()

// 是否启用WebSocket功能（默认开启）
const ENABLE_WEBSOCKET = true

class WebSocketService {
  constructor() {
    this.ws = null
    this.reconnectAttempts = 0
    this.maxReconnectAttempts = 5
    this.reconnectInterval = 3000 // 3秒
    this.pingInterval = null
    // 直接连接到后端服务，不通过网关
    this.url = `ws://localhost:9602/websocket?token=${getToken()}`
    // 原配置 - 通过网关连接
    // const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
    // const host = window.location.host; // 获取当前主机和端口
    // this.url = `${protocol}//${host}/ldzl-qc/websocket?token=${getToken()}`
    this.connected = false
    this.enabled = ENABLE_WEBSOCKET // 是否启用WebSocket
  }

  // 初始化WebSocket连接
  connect() {
    // 如果WebSocket功能未启用，则不进行连接
    if (!this.enabled) {
      console.log('WebSocket功能已禁用，跳过连接')
      return
    }
    
    if (this.ws && this.ws.readyState !== WebSocket.CLOSED) return

    console.log('正在连接WebSocket...', this.url)
    try {
      // 捕获WebSocket创建时可能的异常
      try {
        this.ws = new WebSocket(this.url)
      } catch (initError) {
        console.error('创建WebSocket实例失败:', initError)
        this.scheduleReconnect()
        return
      }
      
      this.ws.onopen = this.onOpen.bind(this)
      this.ws.onmessage = this.onMessage.bind(this)
      this.ws.onerror = this.onError.bind(this)
      this.ws.onclose = this.onClose.bind(this)
    } catch (error) {
      console.error('WebSocket连接错误:', error)
      this.scheduleReconnect()
    }
  }

  // 连接建立成功回调
  onOpen() {
    console.log('WebSocket连接已建立')
    this.connected = true
    this.reconnectAttempts = 0
    
    // 定期发送心跳包
    this.pingInterval = setInterval(() => {
      this.sendPing()
    }, 30000) // 每30秒
    
    // 发布连接成功事件
    WebSocketBus.$emit('websocket-connected')
  }

  // 接收消息回调
  onMessage(event) {
    try {
      const data = JSON.parse(event.data)
      console.log('收到WebSocket消息:', data)
      
      // 处理不同类型的消息
      if (data.type === 'quality_check_created') {
        this.handleQualityCheckCreated(data)
      } else if (data.type === 'quality_check_progress') {
        this.handleQualityCheckProgress(data)
      } else if (data.type === 'quality_check_complete') {
        this.handleQualityCheckComplete(data)
      } else if (data.type === 'work_report_qc_created') {
        this.handleWorkReportQualityCheck(data)
      } else if (data.type === 'ping_response') {
        // 心跳响应，不处理
      } else {
        // 其他未知消息类型，直接发布
        WebSocketBus.$emit('websocket-message', data)
      }
    } catch (error) {
      console.error('解析WebSocket消息出错:', error, event.data)
    }
  }

  // 处理报工生成检测单的消息
  handleWorkReportQualityCheck(data) {
    console.log('收到报工生成检测单通知:', data)
    
    // 构造通知显示参数
    let notificationOptions = {
      title: '新检测单通知',
      message: data.message || '系统已生成新的检测单，请及时处理',
      type: 'info',
      duration: 0,  // 不自动关闭
      position: 'bottom-right',
      onClick: () => {
        // 跳转到相应检验单页面
        const inspectionType = data.inspectionType || '2'  // 默认为过程检验
        let routePath = ''
        
        // 根据检测单类型确定跳转路径
        switch(inspectionType) {
          case '1':  // 来料检验
            routePath = '/qc/IncomingInspection'
            break
          case '2':  // 过程检验
            routePath = '/qc/ProcesInspection'
            break
          case '3':  // 成品检验
            routePath = '/qc/OutgoingInspection'
            break
          case '4':  // 退料检验
            routePath = '/qc/ReturnInspection'
            break
          default:
            routePath = '/qc/ProcesInspection'
  }

        // 发布路由跳转事件
        WebSocketBus.$emit('navigate', {
          path: routePath,
          query: { inspectionCode: data.inspectionCode }
        })
      }
    }
    
    // 显示通知
    Notification(notificationOptions)
    
    // 发布检测单创建事件
    WebSocketBus.$emit('quality-check-created', data)
  }
  
  // 处理质检进度消息
  handleQualityCheckProgress(data) {
    WebSocketBus.$emit('quality-check-progress', data)
  }

  // 处理质检完成消息
  handleQualityCheckComplete(data) {
    WebSocketBus.$emit('quality-check-complete', data)
  }
  
  // 处理质检单创建消息
  handleQualityCheckCreated(data) {
    // 构造通知显示参数
    let notificationOptions = {
      title: '质检单创建通知',
      message: data.message || '新质检单已创建',
      type: 'success',
      duration: 10000,
      position: 'bottom-right'
    }
    
    // 显示通知
    Notification(notificationOptions)
    
    // 发布事件
    WebSocketBus.$emit('quality-check-created', data)
  }

  // 连接错误回调
  onError(event) {
    console.error('WebSocket连接错误:', event)
    this.connected = false
    
    // 记录详细错误信息
    console.error('WebSocket连接失败。请确保后端服务正常运行在9602端口，并检查WebSocket端点配置。')
    console.error('当前连接URL:', this.url)
    
    // 显示错误通知
    Notification.error({
      title: 'WebSocket连接错误',
      message: '无法连接到WebSocket服务，部分实时功能可能不可用',
      duration: 5000
    })
    
    this.scheduleReconnect()
  }

  // 连接关闭回调
  onClose(event) {
    console.log('WebSocket连接已关闭:', event)
    this.connected = false
    
    // 清除心跳定时器
    if (this.pingInterval) {
      clearInterval(this.pingInterval)
      this.pingInterval = null
    }
    
    this.scheduleReconnect()
    
    // 发布连接关闭事件
    WebSocketBus.$emit('websocket-disconnected')
  }

  // 安排重连
  scheduleReconnect() {
    // 如果WebSocket功能未启用，则不进行重连
    if (!this.enabled) return
    
    // 增加指数退避算法，避免频繁重连
    const backoffTime = Math.min(30000, this.reconnectInterval * Math.pow(1.5, this.reconnectAttempts))
    
    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
      console.log('达到最大重连次数，停止重连')
      
      // 显示通知
      Notification.warning({
        title: 'WebSocket连接',
        message: '多次尝试连接失败，已停止重连。请刷新页面重试',
        duration: 0
      })
      return
    }

    console.log(`${backoffTime / 1000}秒后尝试重新连接... (尝试 ${this.reconnectAttempts + 1}/${this.maxReconnectAttempts})`)
    
    setTimeout(() => {
      console.log('正在尝试重新连接...')
      this.reconnectAttempts++
      this.connect()
    }, backoffTime)
  }

  // 发送心跳包
  sendPing() {
    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
      this.ws.send(JSON.stringify({ type: 'ping' }))
      }
  }

  // 发送消息
  sendMessage(message) {
    if (!this.enabled) {
      console.log('WebSocket功能已禁用，不发送消息')
      return false
    }
    
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      console.error('WebSocket未连接，无法发送消息')
      return false
    }

    try {
      const messageStr = typeof message === 'string' ? message : JSON.stringify(message)
      this.ws.send(messageStr)
      return true
    } catch (error) {
      console.error('发送WebSocket消息出错:', error)
      return false
    }
  }

  // 关闭连接
  disconnect() {
    if (!this.ws) return
    
    try {
      this.ws.close()
      this.ws = null
      
      if (this.pingInterval) {
        clearInterval(this.pingInterval)
        this.pingInterval = null
      }
        } catch (error) {
      console.error('关闭WebSocket连接时出错:', error)
    }
  }

  // 设置是否启用WebSocket
  setEnabled(enabled) {
    this.enabled = !!enabled
    
    if (this.enabled && !this.connected) {
      // 如果启用并且未连接，则尝试连接
      this.connect()
    } else if (!this.enabled && this.connected) {
      // 如果禁用并且已连接，则断开连接
      this.disconnect()
    }
  }
}

// 导出单例
export default new WebSocketService()
